JavaScript Symbols: Unika Egenskapsnycklar och Metadata

JavaScript Symbols, som introducerades i ECMAScript 2015 (ES6), erbjuder en mekanism för att skapa unika och oföränderliga egenskapsnycklar. Till skillnad från strängar eller nummer är Symbols garanterat unika i hela din JavaScript-applikation. De erbjuder ett sätt att undvika namnkonflikter, bifoga metadata till objekt utan att störa befintliga egenskaper och anpassa objekts beteende. Denna artikel ger en omfattande översikt av JavaScript Symbols, och täcker deras skapande, användningsområden och bästa praxis.

Vad är JavaScript Symbols?

En Symbol är en primitiv datatyp i JavaScript, liknande nummer, strängar, booleans, null och undefined. Till skillnad från andra primitiva typer är Symbols dock unika. Varje gång du skapar en Symbol får du ett helt nytt, unikt värde. Denna unikhet gör Symbols idealiska för:

• Skapa unika egenskapsnycklar: Att använda Symbols som egenskapsnycklar säkerställer att dina egenskaper inte krockar med befintliga egenskaper eller egenskaper som lagts till av andra bibliotek eller moduler.
• Lagra metadata: Symbols kan användas för att bifoga metadata till objekt på ett sätt som är dolt för standardmässiga uppräkningsmetoder, vilket bevarar objektets integritet.
• Anpassa objekts beteende: JavaScript tillhandahåller en uppsättning välkända Symbols som låter dig anpassa hur objekt beter sig i vissa situationer, som när de itereras eller konverteras till en sträng.

Skapa Symbols

Du skapar en Symbol med hjälp av Symbol()-konstruktorn. Det är viktigt att notera att du inte kan använda new Symbol(); Symbols är inte objekt, utan primitiva värden.

Grundläggande skapande av Symbol

Det enklaste sättet att skapa en Symbol är:

            const mySymbol = Symbol();
console.log(typeof mySymbol); // Utskrift: symbol
            

              
                Copy
              
            
          

Varje anrop till Symbol() genererar ett nytt, unikt värde:

            const symbol1 = Symbol();
const symbol2 = Symbol();
console.log(symbol1 === symbol2); // Utskrift: false
            

              
                Copy
              
            
          

Symbol-beskrivningar

Du kan ange en valfri strängbeskrivning när du skapar en Symbol. Denna beskrivning är användbar för felsökning och loggning, men den påverkar inte Symbolens unikhet.

            const mySymbol = Symbol("myDescription");
console.log(mySymbol.toString()); // Utskrift: Symbol(myDescription)
            

              
                Copy
              
            
          

Beskrivningen är enbart i informationssyfte; två Symbols med samma beskrivning är fortfarande unika:

            const symbolA = Symbol("same description");
const symbolB = Symbol("same description");
console.log(symbolA === symbolB); // Utskrift: false
            

              
                Copy
              
            
          

Använda Symbols som Egenskapsnycklar

Symbols är särskilt användbara som egenskapsnycklar eftersom de garanterar unikhet, vilket förhindrar namnkonflikter när man lägger till egenskaper till objekt.

Lägga till Symbol-egenskaper

Du kan använda Symbols som egenskapsnycklar precis som strängar eller nummer:

            const mySymbol = Symbol("myKey");
const myObject = {};

myObject[mySymbol] = "Hej, Symbol!";

console.log(myObject[mySymbol]); // Utskrift: Hej, Symbol!
            

              
                Copy
              
            
          

Undvika Namnkonflikter

Föreställ dig att du arbetar med ett tredjepartsbibliotek som lägger till egenskaper till objekt. Du kanske vill lägga till dina egna egenskaper utan att riskera att skriva över befintliga. Symbols erbjuder ett säkert sätt att göra detta:

            // Tredjepartsbibliotek (simulerat)
const libraryObject = {
  name: "Library Object",
  version: "1.0"
};

// Din kod
const mySecretKey = Symbol("mySecret");
libraryObject[mySecretKey] = "Topphemlig information";

console.log(libraryObject.name); // Utskrift: Library Object
console.log(libraryObject[mySecretKey]); // Utskrift: Topphemlig information
            

              
                Copy
              
            
          

I detta exempel säkerställer mySecretKey att din egenskap inte krockar med några befintliga egenskaper i libraryObject.

Uppräkning av Symbol-egenskaper

En avgörande egenskap hos Symbol-egenskaper är att de är dolda för standardmässiga uppräkningsmetoder som for...in-loopar och Object.keys(). Detta hjälper till att skydda objektens integritet och förhindrar oavsiktlig åtkomst eller modifiering av Symbol-egenskaper.

            const mySymbol = Symbol("myKey");
const myObject = {
  name: "My Object",
  [mySymbol]: "Symbol Value"
};

console.log(Object.keys(myObject)); // Utskrift: ["name"]

for (let key in myObject) {
  console.log(key); // Utskrift: name
}

            

              
                Copy
              
            
          

För att komma åt Symbol-egenskaper måste du använda Object.getOwnPropertySymbols(), som returnerar en array med alla Symbol-egenskaper på ett objekt:

            const mySymbol = Symbol("myKey");
const myObject = {
  name: "My Object",
  [mySymbol]: "Symbol Value"
};

const symbolKeys = Object.getOwnPropertySymbols(myObject);
console.log(symbolKeys); // Utskrift: [Symbol(myKey)]
console.log(myObject[symbolKeys[0]]); // Utskrift: Symbol Value
            

              
                Copy
              
            
          

Välkända Symbols

JavaScript tillhandahåller en uppsättning inbyggda Symbols, kända som välkända Symbols, som representerar specifika beteenden eller funktionaliteter. Dessa Symbols är egenskaper hos Symbol-konstruktorn (t.ex. Symbol.iterator, Symbol.toStringTag). De låter dig anpassa hur objekt beter sig i olika sammanhang.

Symbol.iterator

Symbol.iterator är en Symbol som definierar standarditeratorn för ett objekt. När ett objekt har en metod med nyckeln Symbol.iterator blir det itererbart, vilket innebär att du kan använda det med for...of-loopar och spread-operatorn (...).

Exempel: Skapa ett anpassat itererbart objekt

            const myCollection = {
  items: [1, 2, 3, 4, 5],
  [Symbol.iterator]: function* () {
    for (let item of this.items) {
      yield item;
    }
  }
};

for (let item of myCollection) {
  console.log(item); // Utskrift: 1, 2, 3, 4, 5
}

console.log([...myCollection]); // Utskrift: [1, 2, 3, 4, 5]
            

              
                Copy
              
            
          

I detta exempel är myCollection ett objekt som implementerar iteratorprotokollet med hjälp av Symbol.iterator. Generatorfunktionen 'yieldar' varje objekt i items-arrayen, vilket gör myCollection itererbart.

Symbol.toStringTag

Symbol.toStringTag är en Symbol som låter dig anpassa strängrepresentationen av ett objekt när Object.prototype.toString() anropas.

Exempel: Anpassa toString()-representationen

            class MyClass {
  get [Symbol.toStringTag]() {
    return 'MyClassInstance';
  }
}

const instance = new MyClass();
console.log(Object.prototype.toString.call(instance)); // Utskrift: [object MyClassInstance]
            

              
                Copy
              
            
          

Utan Symbol.toStringTag skulle utskriften vara [object Object]. Denna Symbol ger ett sätt att ge en mer beskrivande strängrepresentation av dina objekt.

Symbol.hasInstance

Symbol.hasInstance är en Symbol som låter dig anpassa beteendet hos instanceof-operatorn. Normalt kontrollerar instanceof om ett objekts prototypkedja innehåller en konstruktors prototype-egenskap. Symbol.hasInstance låter dig åsidosätta detta beteende.

Exempel: Anpassa instanceof-kontrollen

            class MyClass {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}

console.log([] instanceof MyClass); // Utskrift: true
console.log({} instanceof MyClass); // Utskrift: false
            

              
                Copy
              
            
          

I detta exempel kontrollerar Symbol.hasInstance-metoden om instansen är en array. Detta gör i praktiken att MyClass fungerar som en kontroll för arrayer, oavsett den faktiska prototypkedjan.

Andra Välkända Symbols

JavaScript definierar flera andra välkända Symbols, inklusive:

• Symbol.toPrimitive: Låter dig anpassa ett objekts beteende när det konverteras till ett primitivt värde (t.ex. under aritmetiska operationer).
• Symbol.unscopables: Anger egenskapsnamn som ska undantas från with-satser. (with är generellt sett avrått).
• Symbol.match, Symbol.replace, Symbol.search, Symbol.split: Låter dig anpassa hur objekt beter sig med metoder för reguljära uttryck som String.prototype.match(), String.prototype.replace(), etc.

Globalt Symbol-register

Ibland behöver du dela Symbols över olika delar av din applikation eller till och med mellan olika applikationer. Det globala Symbol-registret erbjuder en mekanism för att registrera och hämta Symbols med en nyckel.

Symbol.for(key)

Metoden Symbol.for(key) kontrollerar om en Symbol med den angivna nyckeln finns i det globala registret. Om den finns, returneras den Symbolen. Om den inte finns, skapas en ny Symbol med nyckeln och registreras i registret.

            const globalSymbol1 = Symbol.for("myGlobalSymbol");
const globalSymbol2 = Symbol.for("myGlobalSymbol");

console.log(globalSymbol1 === globalSymbol2); // Utskrift: true
console.log(Symbol.keyFor(globalSymbol1)); // Utskrift: myGlobalSymbol
            

              
                Copy
              
            
          

Symbol.keyFor(symbol)

Metoden Symbol.keyFor(symbol) returnerar nyckeln som är associerad med en Symbol i det globala registret. Om Symbolen inte finns i registret, returneras undefined.

            const mySymbol = Symbol("localSymbol");
console.log(Symbol.keyFor(mySymbol)); // Utskrift: undefined

const globalSymbol = Symbol.for("myGlobalSymbol");
console.log(Symbol.keyFor(globalSymbol)); // Utskrift: myGlobalSymbol
            

              
                Copy
              
            
          

Viktigt: Symbols som skapats med Symbol() registreras *inte* automatiskt i det globala registret. Endast Symbols som skapats (eller hämtats) med Symbol.for() är en del av registret.

Praktiska Exempel och Användningsfall

Här är några praktiska exempel som visar hur Symbols kan användas i verkliga scenarier:

1. Skapa Pluginsystem

Symbols kan användas för att skapa pluginsystem där olika moduler kan utöka funktionaliteten hos ett kärnobjekt utan att krocka med varandras egenskaper.

            // Kärnobjekt
const coreObject = {
  name: "Core Object",
  version: "1.0"
};

// Plugin 1
const plugin1Key = Symbol("plugin1");
coreObject[plugin1Key] = {
  description: "Plugin 1 lägger till extra funktionalitet",
  activate: function() {
    console.log("Plugin 1 aktiverat");
  }
};

// Plugin 2
const plugin2Key = Symbol("plugin2");
coreObject[plugin2Key] = {
  author: "En annan utvecklare",
  init: function() {
    console.log("Plugin 2 initialiserat");
  }
};

// Åtkomst till plugins
console.log(coreObject[plugin1Key].description); // Utskrift: Plugin 1 lägger till extra funktionalitet
coreObject[plugin2Key].init(); // Utskrift: Plugin 2 initialiserat
            

              
                Copy
              
            
          

I detta exempel använder varje plugin en unik Symbol-nyckel, vilket förhindrar potentiella namnkonflikter och säkerställer att plugins kan samexistera fredligt.

2. Lägga till Metadata till DOM-element

Symbols kan användas för att bifoga metadata till DOM-element utan att störa deras befintliga attribut eller egenskaper.

            const element = document.createElement("div");

const dataKey = Symbol("elementData");
element[dataKey] = {
  type: "widget",
  config: {},
  timestamp: Date.now()
};

// Åtkomst till metadata
console.log(element[dataKey].type); // Utskrift: widget
            

              
                Copy
              
            
          

Detta tillvägagångssätt håller metadata separat från elementets standardattribut, vilket förbättrar underhållbarheten och undviker potentiella konflikter med CSS eller annan JavaScript-kod.

3. Implementera Privata Egenskaper

Även om JavaScript inte har äkta privata egenskaper, kan Symbols användas för att simulera integritet. Genom att använda en Symbol som en egenskapsnyckel kan du göra det svårt (men inte omöjligt) för extern kod att komma åt egenskapen.

            class MyClass {
  #privateSymbol = Symbol("privateData"); // Notera: Denna '#'-syntax är ett *äkta* privat fält introducerat i ES2020, vilket skiljer sig från exemplet

  constructor(data) {
    this[this.#privateSymbol] = data;
  }

  getData() {
    return this[this.#privateSymbol];
  }
}

const myInstance = new MyClass("Känslig information");
console.log(myInstance.getData()); // Utskrift: Känslig information

// Åtkomst till den \"privata\" egenskapen (svårt, men möjligt)
const symbolKeys = Object.getOwnPropertySymbols(myInstance);
console.log(myInstance[symbolKeys[0]]); // Utskrift: Känslig information

            

              
                Copy
              
            
          

Även om Object.getOwnPropertySymbols() fortfarande kan exponera Symbolen, gör det det mindre troligt att extern kod av misstag kommer åt eller modifierar den "privata" egenskapen. Notera: Äkta privata fält (med prefixet `#`) finns nu tillgängliga i modern JavaScript och erbjuder starkare integritetsgarantier.

Bästa Praxis för Användning av Symbols

Här är några bästa praxis att tänka på när du arbetar med Symbols:

• Använd beskrivande Symbol-beskrivningar: Att ge meningsfulla beskrivningar gör felsökning och loggning enklare.
• Överväg det globala Symbol-registret: Använd Symbol.for() när du behöver dela Symbols mellan olika moduler eller applikationer.
• Var medveten om uppräkning: Kom ihåg att Symbol-egenskaper inte är uppräkningsbara som standard, och använd Object.getOwnPropertySymbols() för att komma åt dem.
• Använd Symbols för metadata: Utnyttja Symbols för att bifoga metadata till objekt utan att störa deras befintliga egenskaper.
• Överväg äkta privata fält när stark integritet krävs: Om du behöver genuin integritet, använd prefixet `#` för privata klassfält (tillgängligt i modern JavaScript).

Slutsats

JavaScript Symbols erbjuder en kraftfull mekanism för att skapa unika egenskapsnycklar, bifoga metadata till objekt och anpassa objekts beteende. Genom att förstå hur Symbols fungerar och följa bästa praxis kan du skriva mer robust, underhållbar och kollisionsfri JavaScript-kod. Oavsett om du bygger pluginsystem, lägger till metadata till DOM-element eller simulerar privata egenskaper, är Symbols ett värdefullt verktyg för att förbättra ditt arbetsflöde inom JavaScript-utveckling.